package com.zhixiang.core.util;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;

import com.fr.base.ArrayUtils;
/*
import org.codehaus.jackson.JsonEncoding;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.codehaus.jackson.JsonGenerator; */

public class Utils {
	
	public static boolean isNullOrTemp(String str){
		boolean b=true;
		if (str!=null){
			if (str.length()!=0){
			   b=false;	
			}
		}	
		return b;
	}
	
	public static boolean isNullOrTemp(Integer t){
		boolean b=true;
		if (t!=null){
			
			   b=false;	
			
		}	
		return b;
	}
	
	public static String field2GetMethod(String fieldname){
		if (fieldname.substring(1, 2).toUpperCase().equals(fieldname.substring(1, 2))){
			return "get".concat(fieldname);
		}else{
			return "get".concat(fieldname.substring(0, 1).toUpperCase()).concat(fieldname.substring(1));
		}				
	}
	
	public static String field2SetMethod(String fieldname){
		if (fieldname.substring(1, 2).toUpperCase().equals(fieldname.substring(1, 2))){
			return "set".concat(fieldname);
		}else{
			return "set".concat(fieldname.substring(0, 1).toUpperCase()).concat(fieldname.substring(1));
		}
	}
    /** 
     * 循环向上转型, 获取对象的 DeclaredField 
     * @param object : 子类对象 
     * @param fieldName : 父类中的属性名 
     * @return 父类中的属性对象 
     */  
      
    public static Field getDeclaredField(Class<?> clazz, String fieldName){  
        Field field = null ;  
        for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
            try {  
                field = clazz.getDeclaredField(fieldName) ;  
                return field ;  
            } catch (Exception e) {  
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。  
                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了                    
            }   
        }       
        return null;  
    }

    
    /** 
     * 循环向上转型, 获取对象的 DeclaredField 
     * @param object : 子类对象 
     * @return 父类中的属性对象 
     */  
      
    public static Field[] getDeclaredFields(Class<?> clazz){  
        Field[] field = {} ;  
        for(; clazz != Object.class ; clazz = clazz.getSuperclass()) {    
            field=(Field[]) ArrayUtils.addAll(field, clazz.getDeclaredFields()) ; 
        }       
        return field ;  
    }
	
	public static Class<?> getFieldType(Class<?> clazz,String fieldname) throws SecurityException, NoSuchFieldException{
		String[] fields=fieldname.split("\\.");
		Class<?> cla=clazz;
		for (int i=0;i<fields.length-1;i++){
			cla=getDeclaredField(cla,fields[i]).getType();
		}
		return getDeclaredField(cla,fields[fields.length-1]).getType();
		
	}	
	/** 
     * 直接调用对象方法, 而忽略修饰符(private, protected, default) 
     * @param object : 子类对象 
     * @param methodName : 父类中的方法名 
     * @param parameterTypes : 父类中的方法参数类型 
     * @param parameters : 父类中的方法参数 
     * @return 父类中方法的执行结果 
     */  
      
    public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,  
            Object [] parameters) {  
        //根据 对象、方法名和对应的方法参数 通过反射 调用上面的方法获取 Method 对象  
        Method method = getDeclaredMethod(object, methodName, parameterTypes) ;            
        //抑制Java对方法进行检查,主要是针对私有方法而言  
        method.setAccessible(true) ; 
        try {  
            if(null != method) {                        
                //调用object 的 method 所代表的方法，其方法的参数是 parameters  
                return method.invoke(object, parameters) ;  
            }  
        } catch (IllegalArgumentException e) {  
            e.printStackTrace();  
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
        } catch (InvocationTargetException e) {  
            e.printStackTrace();  
        }  
          
        return null;  
    }  
	/** 
     * 循环向上转型, 获取对象的 DeclaredMethod 
     * @param object : 子类对象 
     * @param methodName : 父类中的方法名 
     * @param parameterTypes : 父类中的方法参数类型 
     * @return 父类中的方法对象  
     */  
      
    public static Method getDeclaredMethod(Object object, String methodName, Class<?> ... parameterTypes){  
        Method method = null ;  
          
        for(Class<?> clazz = object.getClass() ; clazz != Object.class ; clazz = clazz.getSuperclass()) {  
            try {  
                method = clazz.getDeclaredMethod(methodName, parameterTypes) ;  
                return method ;  
            } catch (Exception e) {  
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。  
                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了                
            }  
        }            
        return null;  
    }  

	public static Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
		 
		Class<?> ownerClass = owner.getClass();
	    if (args==null){
	    	args=new Object[0];
	    }	    	
	    Class<?>[] argsClass = new Class[args.length];
		for (int i = 0, j = args.length; i < j; i++) {
		       argsClass[i] = args[i].getClass();
		}
		java.lang.reflect.Method method=null;
		try {
			method = ownerClass.getMethod( methodName, argsClass);
		} catch (Exception e) {
			throw e;
		}	
		Object object=null;
		if (method!=null){
			try {
				object=method.invoke(owner, args);
			} catch (Exception e) {
				throw e;
			}
		}
		return object;
	}
	
	public static Object getPropertyValue (Object entity,String PropertyName){
		Object entity1 = entity;
		String[] as = PropertyName.split("[.]");
		if ((as != null) && (as.length > 0)) {
			for (int j = 0; j < as.length; j++) {
				if (entity1!=null){
					try {
						entity1 = Utils.invokeMethod(entity1, Utils.field2GetMethod(as[j]), new Class[] {});
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				
			}
		} else{
			entity1=null;
		}
		return entity1;
	}
	
	private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",
		"6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
	/**
	 * 
	 * @param byteArray
	 * @return 16 String
	 */
	private static String byteArrayToHexString(byte[] byteArray){
		StringBuffer sb = new StringBuffer();
		for(byte byt:byteArray){
			sb.append(byteToHexString(byt));
		}
		return sb.toString();
	}
	/**
	 * 字节转换为16进制字符串

	 * @param byt 转换字节
	 * @return 16进制字符串

	 */
	private static String byteToHexString(byte byt) {
		int n = byt;
		if (n < 0)
			n = 256 + n;
		return hexDigits[n/16] + hexDigits[n%16];
	}
	/**
	 * 字符串加密

	 * @param code 算法
	 * @param message 待加密串
	 * @return 加密串
	 */
	private static String Encode(String code,String message){
		MessageDigest md;
		String encode = null;
		try {
			md = MessageDigest.getInstance(code);
			encode = byteArrayToHexString(md.digest(message
					.getBytes()));
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return encode;
	}
	/**
	 * 字符串MD5加密
	 * @param message 待加密串
	 * @return MD5加密串
	 */
	public static String md5Encode(String message){
		return Encode("MD5",message);
	}
	/**
	 * 字符串SHA加密
	 * @param message 待加密串
	 * @return SHA加密串
	 */
	public static String shaEncode(String message){
		return Encode("SHA",message);
	}
	/**
	 * 字符串SHA-256加密
	 * @param message 待加密串
	 * @return SHA-256加密串
	 */
	public static String sha256Encode(String message){
		return Encode("SHA-256",message);
	}
	/**
	 * 字符串SHA-512加密
	 * @param message 待加密串
	 * @return SHA-512加密串
	 */
	public static String sha512Encode(String message){
		return Encode("SHA-512",message);
	}
	
	/**
	* 由相对路径获得 绝对路径、File、文件列表，此工具根据 ClassPath寻找路径 注意：本类不要加到jar包中，不然会失效
	* 在Servlet中获得文件真实路径 string file_real_path=getServletContext().getRealPath("/1.swf");
	*
	* @author KyLinD 2009-4-28 http://hi.baidu.com/kylind
	* @version 1.0
	*/
	/**
	* 根据相对路径获得 File
	*
	* @param relativePath
	* 工程下的以"./"开头，web下的以"/"开头，ClassPath下的直接相对路径
	* @return File
	*/
	public static File getFileByRelativePath(String relativePath) {
		return new File(getAbsolutePath(relativePath));
	}

	/**
	 * 根据相对路径获得绝对路径
	 *
	 * @param relativePath
	 *            工程下的以"./"开头，web下的以"/"开头，ClassPath下的直接相对路径
	 * @return 绝对路径字符串
	 */
	public static String getAbsolutePath(String relativePath) {
		String result = null;
		if (null != relativePath) {
			if (relativePath.indexOf("./") == 0) {
				String workspacePath = new File("").getAbsolutePath();
				relativePath = relativePath.substring(2);
				if (relativePath.length() > 0) {
					relativePath = relativePath
							.replace('/', File.separatorChar);
					result = workspacePath + String.valueOf(File.separatorChar)
							+ relativePath;
				} else {
					result = workspacePath;
				}
			} else if (relativePath.indexOf("/") == 0) {
				String webRootPath = getAbsolutePathOfWebRoot();
				if (relativePath.length() > 0) {
					relativePath = relativePath
							.replace('/', File.separatorChar);
					result = webRootPath + relativePath;
				} else {
					result = webRootPath;
				}
			} else {
				String classPath = getAbsolutePathOfClassPath();
				if (relativePath.length() > 0) {
					relativePath = relativePath
							.replace('/', File.separatorChar);
					result = classPath + File.separatorChar + relativePath;
				} else {
					result = classPath;
				}
			}
		}
		return result;
	}

	// 得到WebRoot目录的绝对地址
	private static String getAbsolutePathOfWebRoot() {
		String result = null;
		result = getAbsolutePathOfClassPath();
		result = result.replace(File.separatorChar + "WEB-INF"
				+ File.separatorChar + "classes", "");
		return result;
	}

	// 得到ClassPath的绝对路径
	private static String getAbsolutePathOfClassPath() {
		String result = null;
		try {
			File file = new File(getURLOfClassPath().toURI());
			result = file.getAbsolutePath();
		} catch (URISyntaxException e) {
			e.printStackTrace();
		}
		return result;
	}

	// 得到ClassPath的URL
	private static URL getURLOfClassPath() {
		return getClassLoader().getResource("");
	}

	// 得到类加载器
	private static ClassLoader getClassLoader() {
		return Utils.class.getClassLoader();
	}

	
	public static String upperFirst(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }
        return Character.toUpperCase(s.charAt(0)) + s.substring(1);
    }
	
	   /*添加年份*/
		public static Map<String,String> getYearMap(){
	        Map<String,String> yearMap = new LinkedHashMap<String,String>();
	        int currentYear = Integer.parseInt(getCurrentYear());
	        for(int i = 2014; i < currentYear + 3; i++){
	            yearMap.put(String.valueOf(i), String.valueOf(i) + "年");
	        }
	        return yearMap;
	    }
		
		public static String getCurrentYear(){
	        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
	        return sdf.format(new Date());
	    }    
		
	/**
		 * 获取项目WEB-INF的绝对路径
		 * @auth 王华文
		 * @return
		 */
		public static String getWebinfPath(){
			//file:/D:/JavaWeb/.metadata/.me_tcat/webapps/TestBeanUtils/WEB-INF/classes/
			String path=Thread.currentThread().getContextClassLoader().getResource("").toString();
			path=path.replace("file:", ""); //去掉file:
			path=path.replace("classes/", ""); //去掉class/
			path=path.substring(1); //去掉第一个\,如 \D:\JavaWeb...
			//System.out.println(path);
			return path;
		}
}
